package com.bdqn.service.impl;

import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bdqn.mapper.RightMapper;
import com.bdqn.mapper.RoleMapper;
import com.bdqn.mapper.RoleRightMapper;
import com.bdqn.pojo.Role;
import com.bdqn.pojo.RoleRight;
import com.bdqn.service.RightService;
import com.bdqn.service.RoleService;
import jakarta.annotation.Resource;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

/**
 * 角色Service实现
 *
 * @author LILIBO
 * @since 2024/09/07
 */
@Service
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements RoleService {

    @Resource
    private RoleMapper roleMapper;

    @Resource
    private RightMapper rightMapper;

    @Resource
    private RoleRightMapper roleRightMapper;

    @Resource
    private RightService rightService;

    /**
     * 保存角色信息
     *
     * @param role
     * @return
     */
    @Override
    public boolean saveRole(Role role) {
        return false;
    }

    /**
     * 获取所有角色信息
     *
     * @return
     */
    @Override
    @Cacheable(value = "role", key = "'all'", unless = "#result==null")
    public List<Role> findAll() {
        return super.list();
    }

    /**
     * 根据角色名分页查询用户数据
     *
     * @param roleName
     * @param page
     * @return
     */
    @Override
    @Cacheable(value = "role", key = "'page:' + #page.current + '-' + #page.size + '-' + #roleName", condition = "#page.current!=null and #page.size!=null", unless = "#result==null")
    public Page<Role> findPage(String roleName, Page page) {
        QueryWrapper<Role> qw = new QueryWrapper<>();
        if (roleName != null && !roleName.isEmpty()) {
            qw.like("role_name", roleName);
        }
        return super.page(page, qw);
    }

    /**
     * 根据用户ID获得权限信息
     *
     * @param userId
     * @return
     */
    @Override
    public Role getByUserId(Long userId) {
        return roleMapper.getByUserId(userId);
    }

    /**
     * 查询角色名是否存在
     *
     * @param roleName
     * @param exceptRoleId
     */
    @Override
    public Role getByRoleNameExceptRoleId(String roleName, Long exceptRoleId) {
        JSONObject json = new JSONObject();
        QueryWrapper<Role> qw = new QueryWrapper<>();
        if (exceptRoleId != null) {
            qw.ne("role_id", exceptRoleId); // role_id不等于传入的ID
        }
        qw.eq("role_name", roleName);
        return baseMapper.selectOne(qw);
    }

    /**
     * 保存角色及对应的权限（兼容添加和修改）
     *
     * @param role
     * @param rightCodes
     * @return
     */
    @Override
    @Transactional // 开启事务
    @CacheEvict(cacheNames = "role", allEntries = true) // 清除缓存
    public boolean saveRoleAndRight(Role role, String[] rightCodes) throws RuntimeException {
        // 保存角色信息（sys_role）
        boolean flag = baseMapper.insertOrUpdate(role);
        if (!flag) {
            return false;
        }

        /* int a = 10;
        if (a > 0) {
            // 模拟一个异常（@Transactional 开启事务，方法抛出异常时将会回滚）
            throw new RuntimeException("模拟一个异常");
        } */

        // 设置角色对应权限的关系信息（sys_role_right）
        QueryWrapper<RoleRight> qw = new QueryWrapper<>();
        qw.eq("rf_role_id", role.getRoleId());

        // 先删除角色对应的权限数据
        roleRightMapper.delete(qw);

        // 将rightCodes中的角色编号与角色对应保存
        List<RoleRight> roleRights = new ArrayList<>();
        for (String rightCode : rightCodes) {
            roleRights.add(new RoleRight(role.getRoleId(), rightCode));
        }

        // 再批量添加角色权限对应数据
        roleRightMapper.insert(roleRights);

        // 没有异常，表示操作成功
        return true;
    }

    /**
     * 根据角色ID删除角色
     *
     * @param roleId
     * @return
     */
    @Override
    @Transactional // 开启事务
    @CacheEvict(cacheNames = "role", allEntries = true) // 清除缓存
    public boolean del(Long roleId) {
        // 删除角色对应权限的关系（sys_role_right）
        QueryWrapper<RoleRight> qw = new QueryWrapper<>();
        qw.eq("rf_role_id", roleId);
        // 先删除角色对应的权限数据（sys_role）
        roleRightMapper.delete(qw);

        // 删除角色信息
        roleMapper.deleteById(roleId);

        return true;
    }

}




